#!/usr/bin/env node

/**
 * 步骤3：根据内容查找key进行替换
 * 
 * 功能：
 * 1. 读取步骤2生成的翻译映射文件
 * 2. 在源码中精确查找对应的中文内容
 * 3. 将找到的内容替换为对应的国际化key调用
 * 4. 支持预览模式，先查看替换效果
 */

const fs = require('fs');
const path = require('path');

class I18nReplacer {
  constructor() {
    this.projectRoot = path.resolve(__dirname, '../');
    this.srcPath = path.join(this.projectRoot, 'src');
    
    
    this.fileExtensions = ['.vue', '.js', '.ts'];
    this.excludeDirs = ['node_modules', '.git', 'dist', 'build', 'i18n', 'uni_modules'];
    
    // 翻译映射数据
    this.translationMapping = null;
    this.contentToKeyMap = new Map(); // 中文内容 -> key 的映射
    
    // 替换统计
    this.replaceStats = {
      processedFiles: 0,
      modifiedFiles: 0,
      totalReplacements: 0,
      replacements: [] // 详细的替换记录
    };
    
    // 预览模式
    this.isPreviewMode = false;
    
    console.log('🔄 步骤3：根据内容查找key进行替换');
    console.log(`📁 项目根目录: ${this.projectRoot}`);
  }

  /**
   * 获取翻译映射数据
   */
  getTranslationMapping() {
    console.log('\n📚 获取翻译映射...');
    
    const I18nTranslator = require('./step2-translate.js');
    const translator = new I18nTranslator();
    
    // 执行翻译过程
    translator.getNewContent();
    translator.initializeTranslations();
    
    // 执行翻译（但不更新文件）
    const performTranslationSync = () => {
      for (const item of translator.newContentData.items) {
        const { content, key } = item;
        
        // 中文（源语言）
        translator.translations.zh[key] = content;
        
        // 翻译到其他语言
        for (const lang of translator.supportedLanguages) {
          if (lang !== 'zh') {
            try {
              const translatedText = translator.translateToSync(content, lang);
              translator.translations[lang][key] = translatedText;
            } catch (error) {
              translator.translations[lang][key] = `[${content}]`;
            }
          }
        }
      }
    };
    
    performTranslationSync();
    
    this.translationMapping = {
      timestamp: new Date().toISOString(),
      languages: translator.supportedLanguages,
      totalCount: Object.keys(translator.translations.zh || {}).length,
      translations: translator.translations
    };
    
    console.log(`✅ 获取了 ${this.translationMapping.totalCount} 个翻译映射`);
    console.log(`🌐 支持语言: ${this.translationMapping.languages.join(', ')}`);
    
    // 构建内容到key的映射
    this.buildContentToKeyMap();
    
    if (this.translationMapping.totalCount === 0) {
      console.log('🎉 没有内容需要替换！');
      process.exit(0);
    }
  }

  /**
   * 构建内容到key的映射
   */
  buildContentToKeyMap() {
    const zhTranslations = this.translationMapping.translations.zh || {};
    
    for (const [key, content] of Object.entries(zhTranslations)) {
      this.contentToKeyMap.set(content, key);
    }
    
    console.log(`🔑 构建了 ${this.contentToKeyMap.size} 个内容-key映射`);
    
    // 显示一些示例
    console.log('\n📋 映射示例:');
    let count = 0;
    for (const [content, key] of this.contentToKeyMap) {
      if (count < 5) {
        console.log(`   "${content}" -> ${key}`);
        count++;
      }
    }
    if (this.contentToKeyMap.size > 5) {
      console.log(`   ... 还有 ${this.contentToKeyMap.size - 5} 个映射`);
    }
  }

  /**
   * 处理所有文件
   */
  processAllFiles() {
    const mode = this.isPreviewMode ? '预览' : '替换';
    console.log(`\n🔄 开始${mode}处理...`);
    
    this.processDirectory(this.srcPath);
    
    console.log(`\n✅ ${mode}完成！`);
    console.log(`📊 处理统计:`);
    console.log(`   - 处理文件: ${this.replaceStats.processedFiles} 个`);
    console.log(`   - 修改文件: ${this.replaceStats.modifiedFiles} 个`);
    console.log(`   - 总替换次数: ${this.replaceStats.totalReplacements} 次`);
  }

  processDirectory(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        const stat = fs.statSync(filePath);
        
        if (stat.isDirectory()) {
          if (!this.excludeDirs.includes(file)) {
            this.processDirectory(filePath);
          }
        } else {
          const ext = path.extname(file);
          if (this.fileExtensions.includes(ext)) {
            this.processFile(filePath);
          }
        }
      });
    } catch (error) {
      console.warn(`⚠️ 处理目录 ${dirPath} 失败:`, error.message);
    }
  }

  processFile(filePath) {
    try {
      this.replaceStats.processedFiles++;
      
      let content = fs.readFileSync(filePath, 'utf8');
      const originalContent = content;
      
      // 按内容长度排序，先处理长内容避免部分匹配问题
      const sortedContents = Array.from(this.contentToKeyMap.keys())
        .sort((a, b) => b.length - a.length);
      
      let fileReplacements = [];
      
      for (const chineseContent of sortedContents) {
        const key = this.contentToKeyMap.get(chineseContent);
        const result = this.replaceContentInFile(content, chineseContent, key, filePath);
        
        if (result.modified) {
          content = result.content;
          fileReplacements.push(...result.replacements);
        }
      }
      
      // 如果有修改
      if (content !== originalContent) {
        this.replaceStats.modifiedFiles++;
        this.replaceStats.totalReplacements += fileReplacements.length;
        this.replaceStats.replacements.push({
          file: path.relative(this.projectRoot, filePath),
          replacements: fileReplacements
        });
        
        if (!this.isPreviewMode) {
          // 实际写入文件
          fs.writeFileSync(filePath, content, 'utf8');
        }
        
        const relativePath = path.relative(this.projectRoot, filePath);
        const mode = this.isPreviewMode ? '预览' : '✅';
        console.log(`${mode} ${relativePath} (${fileReplacements.length} 处替换)`);
        
        // 在预览模式下显示详细信息
        if (this.isPreviewMode && fileReplacements.length <= 5) {
          fileReplacements.forEach(replacement => {
            console.log(`   行 ${replacement.line}: "${replacement.original}" -> ${replacement.key}`);
          });
        }
      }
      
    } catch (error) {
      console.warn(`⚠️ 处理文件 ${filePath} 失败:`, error.message);
    }
  }

  /**
   * 在文件内容中替换指定的中文内容
   */
  replaceContentInFile(content, chineseContent, key, filePath) {
    const lines = content.split('\n');
    let modified = false;
    let replacements = [];
    
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i];
      
      // 跳过已经国际化的行
      if (line.includes('$t(') || line.includes('this.$t(')) {
        continue;
      }
      
      // 跳过注释和console语句
      if (this.isCommentLine(line) || this.isConsoleStatement(line)) {
        continue;
      }
      
      // 检查这行是否包含要替换的内容
      if (line.includes(chineseContent)) {
        const newLine = this.smartReplaceInLine(line, chineseContent, key);
        
        if (newLine !== line) {
          lines[i] = newLine;
          modified = true;
          
          replacements.push({
            line: i + 1,
            original: chineseContent,
            key: key,
            context: line.trim()
          });
        }
      }
    }
    
    return {
      content: lines.join('\n'),
      modified: modified,
      replacements: replacements
    };
  }

  /**
   * 在单行中智能替换中文内容
   */
  smartReplaceInLine(line, chineseContent, key) {
    const escapedContent = this.escapeRegex(chineseContent);
    
    // 判断文件类型（Vue文件包含template标签）
    const isVueTemplate = line.includes('<') && line.includes('>');
    
    let result = line;
    
    if (isVueTemplate) {
      // Vue template中的替换
      
      // 1. 属性绑定: prop="中文" -> :prop="$t('key')"
      result = result.replace(
        new RegExp(`(\\s+)(\\w+)=(['"])${escapedContent}\\3`, 'g'),
        `$1:$2="$t('${key}')"`
      );
      
      // 2. 插值表达式: {{ '中文' }} -> {{ $t('key') }}
      result = result.replace(
        new RegExp(`\\{\\{\\s*(['"])${escapedContent}\\1\\s*\\}\\}`, 'g'),
        `{{ $t('${key}') }}`
      );
      
      // 3. 文本节点: >中文< -> >{{ $t('key') }}<
      result = result.replace(
        new RegExp(`(>)\\s*${escapedContent}\\s*(<)`, 'g'),
        `$1{{ $t('${key}') }}$2`
      );
      
    } else {
      // JavaScript代码中的替换
      
      // 1. 简单字符串: "中文" 或 '中文'
      result = result.replace(
        new RegExp(`(['"])${escapedContent}\\1`, 'g'),
        `this.$t('${key}')`
      );
      
      // 2. 模板字符串: `中文`
      result = result.replace(
        new RegExp('`' + escapedContent + '`', 'g'),
        `this.$t('${key}')`
      );
      
      // 3. 对象属性值（需要保持对象结构）
      result = result.replace(
        new RegExp(`(\\w+\\s*:\\s*)(['"])${escapedContent}\\2`, 'g'),
        `$1this.$t('${key}')`
      );
    }
    
    return result;
  }

  /**
   * 转义正则表达式特殊字符
   */
  escapeRegex(text) {
    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  }

  isCommentLine(line) {
    const trimmed = line.trim();
    return trimmed.startsWith('//') || trimmed.startsWith('*') || 
           trimmed.startsWith('/*') || trimmed.startsWith('<!--') ||
           trimmed.includes('<!--') || trimmed.includes('-->');
  }

  isConsoleStatement(line) {
    return line.includes('console.') || line.includes('console[');
  }


  /**
   * 显示详细的替换预览
   */
  showDetailedPreview() {
    if (!this.isPreviewMode || this.replaceStats.replacements.length === 0) return;
    
    console.log('\n📋 详细替换预览:');
    console.log('='.repeat(80));
    
    this.replaceStats.replacements.forEach(fileReplacement => {
      console.log(`\n📄 ${fileReplacement.file}:`);
      
      fileReplacement.replacements.forEach(replacement => {
        console.log(`   行 ${replacement.line}: "${replacement.original}" -> $t('${replacement.key}')`);
        console.log(`   上下文: ${replacement.context}`);
      });
    });
    
    console.log('\n='.repeat(80));
  }

  /**
   * 生成报告
   */
  generateReport() {
    const mode = this.isPreviewMode ? '预览' : '替换';
    
    console.log(`\n📊 ${mode}报告:`);
    console.log('='.repeat(60));
    console.log(`📝 处理模式: ${this.isPreviewMode ? '预览模式' : '实际替换'}`);
    console.log(`📊 处理统计:`);
    console.log(`   - 处理文件: ${this.replaceStats.processedFiles} 个`);
    console.log(`   - 修改文件: ${this.replaceStats.modifiedFiles} 个`);
    console.log(`   - 总替换次数: ${this.replaceStats.totalReplacements} 次`);
    
    console.log('='.repeat(60));
    
    if (this.isPreviewMode && this.replaceStats.modifiedFiles > 0) {
      console.log('\n💡 预览完成，如需实际替换请运行:');
      console.log('   node scripts/step3-replace.js');
    } else if (!this.isPreviewMode && this.replaceStats.modifiedFiles > 0) {
      console.log('\n💡 替换完成，建议：');
      console.log('   1. 检查修改的文件确保替换正确');
      console.log('   2. 运行项目测试确保功能正常');
      console.log('   3. 如有问题可以用git回滚');
    } else if (this.replaceStats.modifiedFiles === 0) {
      console.log('\n🎉 没有找到需要替换的内容！');
      console.log('   所有匹配的内容可能已经被国际化了');
    }
  }

  /**
   * 主运行方法
   */
  run() {
    // 检查命令行参数
    const args = process.argv.slice(2);
    this.isPreviewMode = args.includes('--preview') || args.includes('-p');
    
    if (this.isPreviewMode) {
      console.log('👀 运行在预览模式下');
    }
    
    try {
      // 1. 获取翻译映射
      this.getTranslationMapping();
      
      // 2. 处理所有文件
      this.processAllFiles();
      
      // 3. 显示详细预览（仅预览模式）
      this.showDetailedPreview();
      
      // 4. 生成报告
      this.generateReport();
      
      console.log('\n🎉 步骤3完成！');
      
      if (this.isPreviewMode) {
        console.log('\n📝 这是预览模式，没有修改任何文件');
      }
      
    } catch (error) {
      console.error('❌ 步骤3失败:', error);
      process.exit(1);
    }
  }
}

// 运行脚本
if (require.main === module) {
  const replacer = new I18nReplacer();
  replacer.run();
}

module.exports = I18nReplacer;